{
 "cells": [
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "### 基础知识\n",
    "1. Python 中的列表可以动态地改变，⽽ NumPy 数组是不可以的，它在创建时就有固定⼤⼩了。改变 Numpy 数组⻓度的话，会新创建⼀个新的数组并且删除原数组。\n",
    "2. NumPy 数组中的数据类型必须是⼀样的，⽽列表中的元素可以是多样的。\n",
    "3. NumPy 针对 NumPy 数组⼀系列的运算进⾏了优化，使得其速度特别快，并且相对于Python 中的列表，同等操作只需使⽤更少的内存。"
   ],
   "id": "dd208cab92ecea09"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "",
   "id": "8358e66bb195cdbe"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-05T15:18:08.790232Z",
     "start_time": "2025-05-05T15:18:08.768522Z"
    }
   },
   "cell_type": "code",
   "source": "import numpy as np",
   "id": "fa2ed06a22bbd38a",
   "outputs": [],
   "execution_count": 2
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-05-05T15:18:10.794583Z",
     "start_time": "2025-05-05T15:18:10.783585Z"
    }
   },
   "cell_type": "code",
   "source": [
    "arr_1_d = np.asarray([1]) # 创建一维数组\n",
    "arr_2_d = np.asarray([[1,2,1],[3,4,5],[5,6,1],[5,6,1]], dtype='int32') # 创建二维数组 通过dtype指定类型,否则NumPy会自动识别类型\n",
    "print(arr_1_d)\n",
    "print(arr_2_d)"
   ],
   "id": "2d2b93a0c73d9cd0",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1]\n",
      "[[1 2 1]\n",
      " [3 4 5]\n",
      " [5 6 1]\n",
      " [5 6 1]]\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-04-28T17:35:39.303526Z",
     "start_time": "2025-04-28T17:35:39.281528Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 数组的维度(轴)的个数---这里的维度可以理解成数组元组的长度\n",
    "print(arr_1_d.ndim)\n",
    "print(arr_2_d.ndim)"
   ],
   "id": "5b065e608d723f1a",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n"
     ]
    }
   ],
   "execution_count": 51
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-04-28T17:36:00.271769Z",
     "start_time": "2025-04-28T17:36:00.258421Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 数组的形状----是⼀个整数的元组，元组的⻓度等于 ndim。这个例子可以理解成arr_2_d的形状是4个有3个元素的数组\n",
    "print(arr_1_d.shape)\n",
    "print(arr_2_d.shape)"
   ],
   "id": "3f5f268fb35e8205",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1,)\n",
      "(4, 3)\n"
     ]
    }
   ],
   "execution_count": 56
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-04-28T17:39:50.374390Z",
     "start_time": "2025-04-28T17:39:50.354390Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 对数组形状进行变换, 需保证变换后元素数量与原来一致\n",
    "arr_2_d.reshape((6,2))"
   ],
   "id": "840ccd20f7161cf2",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [1, 3],\n",
       "       [4, 5],\n",
       "       [5, 6],\n",
       "       [1, 5],\n",
       "       [6, 1]])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 64
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "### reshape的order参数:\n",
    "* ‘C’：默认参数，使⽤类似 C-like 语⾔（⾏优先）中的索引⽅式进⾏读写。\n",
    "* ‘F’：使⽤类似 Fortran-like 语⾔（列优先）中的索引⽅式进⾏读写。\n",
    "* ‘A’：原数组如果是按照‘C’的⽅式存储数组，则⽤‘C’的索引对数组进⾏ reshape，否则使⽤’F’的索引⽅式。"
   ],
   "id": "cf284038881cf911"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-04-28T17:46:00.972326Z",
     "start_time": "2025-04-28T17:46:00.946326Z"
    }
   },
   "cell_type": "code",
   "source": "np.reshape(arr_2_d, (12,1), 'F') # 行列优先问题",
   "id": "c6bdaa9897672797",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [3],\n",
       "       [5],\n",
       "       [5],\n",
       "       [2],\n",
       "       [4],\n",
       "       [6],\n",
       "       [6],\n",
       "       [1],\n",
       "       [5],\n",
       "       [1],\n",
       "       [1]])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 69
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-04-28T17:50:06.664779Z",
     "start_time": "2025-04-28T17:50:06.647772Z"
    }
   },
   "cell_type": "code",
   "source": "arr_2_d.size #数组元素数量",
   "id": "be3ce427461634b2",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int32')"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 74
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-04-28T17:50:18.726529Z",
     "start_time": "2025-04-28T17:50:18.701529Z"
    }
   },
   "cell_type": "code",
   "source": "arr_2_d.dtype #数组元素类型",
   "id": "3085ee17ca739d3b",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int32')"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 75
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-04-28T17:53:33.451228Z",
     "start_time": "2025-04-28T17:53:33.424850Z"
    }
   },
   "cell_type": "code",
   "source": [
    "arr_2_d_int8 = arr_2_d.astype('int8') #类型转换 astype会创建一个新的数组 而非在原有基础上改变\n",
    "print(arr_2_d.dtype)\n",
    "print(arr_2_d_int8.dtype)\n",
    "arr_2_d.dtype='int16' #也可以直接转换\n",
    "arr_2_d"
   ],
   "id": "8a9ea4cf3d8eb7d",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int16\n",
      "int8\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 2, 0, 1, 0],\n",
       "       [3, 0, 4, 0, 5, 0],\n",
       "       [5, 0, 6, 0, 1, 0],\n",
       "       [5, 0, 6, 0, 1, 0]], dtype=int16)"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 82
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-04-28T17:59:51.766694Z",
     "start_time": "2025-04-28T17:59:51.740693Z"
    }
   },
   "cell_type": "code",
   "source": "np.ones(shape=(2,3), dtype='int32') * 12 #指定一个全是12的数组",
   "id": "be985efbe54a633c",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[12, 12, 12],\n",
       "       [12, 12, 12]])"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 96
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "使⽤ np.arange([start, ]stop, [step, ]dtype=None) 创建⼀个在[start, stop) 区间的数组，元素之间的跨度是 step。\n",
    "\n",
    "start 是可选参数，默认为 0。stop 是必须参数，区间的终点，请注意，刚才说的区间是⼀个左闭右开区间，所以数组并不包含 stop。step 是可选参数，默认是 1。"
   ],
   "id": "6a0c92fe588a6196"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-04-28T18:01:46.484337Z",
     "start_time": "2025-04-28T18:01:46.455331Z"
    }
   },
   "cell_type": "code",
   "source": "np.arange(2,15,2)",
   "id": "e07e10a46416b45d",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  4,  6,  8, 10, 12, 14])"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 100
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "⽤ np.linspace（start, stop, num=50, endpoint=True, retstep=False, dtype=None）创建⼀个数组，具体就是创建⼀个从开始数值到结束数值的等差数列。",
   "id": "72780e8f57a35b25"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-04-28T18:05:28.111802Z",
     "start_time": "2025-04-28T18:05:28.097804Z"
    }
   },
   "cell_type": "code",
   "source": "np.linspace(start=2, stop=5, num=50)",
   "id": "794f080b722fb099",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2.        , 2.06122449, 2.12244898, 2.18367347, 2.24489796,\n",
       "       2.30612245, 2.36734694, 2.42857143, 2.48979592, 2.55102041,\n",
       "       2.6122449 , 2.67346939, 2.73469388, 2.79591837, 2.85714286,\n",
       "       2.91836735, 2.97959184, 3.04081633, 3.10204082, 3.16326531,\n",
       "       3.2244898 , 3.28571429, 3.34693878, 3.40816327, 3.46938776,\n",
       "       3.53061224, 3.59183673, 3.65306122, 3.71428571, 3.7755102 ,\n",
       "       3.83673469, 3.89795918, 3.95918367, 4.02040816, 4.08163265,\n",
       "       4.14285714, 4.20408163, 4.26530612, 4.32653061, 4.3877551 ,\n",
       "       4.44897959, 4.51020408, 4.57142857, 4.63265306, 4.69387755,\n",
       "       4.75510204, 4.81632653, 4.87755102, 4.93877551, 5.        ])"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 105
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-04-28T18:10:29.658431Z",
     "start_time": "2025-04-28T18:10:29.541900Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "X = np.arange(-50, 51, 2)\n",
    "Y = (X*(X+1))**2\n",
    "plt.plot(X, Y, color='blue')\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "id": "39fa151e10bf0a5a",
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\liyan\\AppData\\Local\\Temp\\ipykernel_46176\\3402180157.py:6: UserWarning: No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n",
      "  plt.legend()\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 114
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
